home *** CD-ROM | disk | FTP | other *** search
/ Visual Cafe 3 / Visual Cafe 3.ISO / Vcafe / JFC.bin / ReaderCharStream.java < prev    next >
Text File  |  1998-06-30  |  8KB  |  327 lines
  1. /*
  2.  * @(#)ReaderCharStream.java    1.2 98/03/12
  3.  * 
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  */
  20. package com.sun.java.swing.text.html;
  21.  
  22. /**
  23.  * Modified implementation of CharStream that uses Reader
  24.  *
  25.  * @version    1.2 03/12/98
  26.  * @author      Makarand Gokhale
  27.  */
  28. final class ReaderCharStream implements  CharStream 
  29. {
  30.   public static final boolean staticFlag = false;
  31.   int bufsize;
  32.   int available;
  33.   int tokenBegin;
  34.   public int bufpos = -1;
  35.   private int bufline[];
  36.   private int bufcolumn[];
  37.  
  38.   private int column = 0;
  39.   private int line = 1;
  40.  
  41.   private boolean prevCharIsCR = false;
  42.   private boolean prevCharIsLF = false;
  43.  
  44.   private java.io.Reader reader;
  45.  
  46.   private char[] buffer;
  47.   private int maxNextCharInd = 0;
  48.   private int inBuf = 0;
  49.  
  50.   private final void ExpandBuff(boolean wrapAround)
  51.   {
  52.      char[] newbuffer = new char[bufsize + 2048];
  53.      int newbufline[] = new int[bufsize + 2048];
  54.      int newbufcolumn[] = new int[bufsize + 2048];
  55.  
  56.      try
  57.      {
  58.         if (wrapAround)
  59.         {
  60.            System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
  61.            System.arraycopy(buffer, 0, newbuffer,
  62.                                              bufsize - tokenBegin, bufpos);
  63.            buffer = newbuffer;
  64.  
  65.            System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
  66.            System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
  67.            bufline = newbufline;
  68.  
  69.            System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
  70.            System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
  71.            bufcolumn = newbufcolumn;
  72.  
  73.            maxNextCharInd = (bufpos += (bufsize - tokenBegin));
  74.         }
  75.         else
  76.         {
  77.            System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
  78.            buffer = newbuffer;
  79.  
  80.            System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
  81.            bufline = newbufline;
  82.  
  83.            System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
  84.            bufcolumn = newbufcolumn;
  85.  
  86.            maxNextCharInd = (bufpos -= tokenBegin);
  87.         }
  88.      }
  89.      catch (Throwable t)
  90.      {
  91.         throw new Error(t.getMessage());
  92.      }
  93.  
  94.  
  95.      bufsize += 2048;
  96.      available = bufsize;
  97.      tokenBegin = 0;
  98.   }
  99.  
  100.   private final void FillBuff() throws java.io.IOException
  101.   {
  102.      if (maxNextCharInd == available)
  103.      {
  104.         if (available == bufsize)
  105.         {
  106.            if (tokenBegin > 2048)
  107.            {
  108.               bufpos = maxNextCharInd = 0;
  109.               available = tokenBegin;
  110.            }
  111.            else if (tokenBegin < 0)
  112.               bufpos = maxNextCharInd = 0;
  113.            else
  114.               ExpandBuff(false);
  115.         }
  116.         else if (available > tokenBegin)
  117.            available = bufsize;
  118.         else if ((tokenBegin - available) < 2048)
  119.            ExpandBuff(true);
  120.         else
  121.            available = tokenBegin;
  122.      }
  123.  
  124.      int i;
  125.      try {
  126.         if ((i = reader.read(buffer, maxNextCharInd,
  127.                                     available - maxNextCharInd)) == -1)
  128.         {
  129.            reader.close();
  130.            throw new java.io.IOException();
  131.         }
  132.         else
  133.            maxNextCharInd += i;
  134.         return;
  135.      }
  136.      catch(java.io.IOException e) {
  137.         --bufpos;
  138.         backup(0);
  139.         if (tokenBegin == -1)
  140.            tokenBegin = bufpos;
  141.         throw e;
  142.      }
  143.   }
  144.  
  145.   public final char BeginToken() throws java.io.IOException
  146.   {
  147.      tokenBegin = -1;
  148.      char c = readChar();
  149.      tokenBegin = bufpos;
  150.  
  151.      return c;
  152.   }
  153.  
  154.   private final void UpdateLineColumn(char c)
  155.   {
  156.      column++;
  157.  
  158.      if (prevCharIsLF)
  159.      {
  160.         prevCharIsLF = false;
  161.         line += (column = 1);
  162.      }
  163.      else if (prevCharIsCR)
  164.      {
  165.         prevCharIsCR = false;
  166.         if (c == '\n')
  167.         {
  168.            prevCharIsLF = true;
  169.         }
  170.         else
  171.            line += (column = 1);
  172.      }
  173.  
  174.      switch (c)
  175.      {
  176.         case '\r' :
  177.            prevCharIsCR = true;
  178.            break;
  179.         case '\n' :
  180.            prevCharIsLF = true;
  181.            break;
  182.         case '\t' :
  183.            column += (9 - (column & 07));
  184.            break;
  185.         default :
  186.            break;
  187.      }
  188.  
  189.      bufline[bufpos] = line;
  190.      bufcolumn[bufpos] = column;
  191.   }
  192.  
  193.   public final char readChar() throws java.io.IOException
  194.   {
  195.      if (inBuf > 0)
  196.      {
  197.         --inBuf;
  198.         return buffer[(bufpos == bufsize - 1) ? (bufpos = 0) : ++bufpos];
  199.      }
  200.  
  201.      if (++bufpos >= maxNextCharInd)
  202.         FillBuff();
  203.  
  204.      char c = buffer[bufpos];
  205.  
  206.      UpdateLineColumn(c);
  207.      return (c);
  208.   }
  209.  
  210.   /**
  211.    * @deprecated 
  212.    * @see #getEndColumn
  213.    */
  214.  
  215.   public final int getColumn() {
  216.      return bufcolumn[bufpos];
  217.   }
  218.  
  219.   /**
  220.    * @deprecated 
  221.    * @see #getEndLine
  222.    */
  223.  
  224.   public final int getLine() {
  225.      return bufline[bufpos];
  226.   }
  227.  
  228.   public final int getEndColumn() {
  229.      return bufcolumn[bufpos];
  230.   }
  231.  
  232.   public final int getEndLine() {
  233.      return bufline[bufpos];
  234.   }
  235.  
  236.   public final int getBeginColumn() {
  237.      return bufcolumn[tokenBegin];
  238.   }
  239.  
  240.   public final int getBeginLine() {
  241.      return bufline[tokenBegin];
  242.   }
  243.  
  244.   public final void backup(int amount) {
  245.  
  246.     inBuf += amount;
  247.     if ((bufpos -= amount) < 0)
  248.        bufpos += bufsize;
  249.   }
  250.  
  251.   public ReaderCharStream(java.io.Reader dReader, int startline,
  252.   int startcolumn, int buffersize)
  253.   {
  254.     reader = dReader;
  255.     line = startline;
  256.     column = startcolumn - 1;
  257.  
  258.     available = bufsize = buffersize;
  259.     buffer = new char[buffersize];
  260.     bufline = new int[buffersize];
  261.     bufcolumn = new int[buffersize];
  262.   }
  263.  
  264.   public ReaderCharStream(java.io.Reader dReader, int startline,
  265.                                                            int startcolumn)
  266.   {
  267.      this(dReader, startline, startcolumn, 4096);
  268.   }
  269.   public void ReInit(java.io.Reader dReader, int startline,
  270.   int startcolumn, int buffersize)
  271.   {
  272.     reader = dReader;
  273.     line = startline;
  274.     column = startcolumn - 1;
  275.  
  276.     if (buffer == null || buffersize != buffer.length)
  277.     {
  278.       available = bufsize = buffersize;
  279.       buffer = new char[buffersize];
  280.       bufline = new int[buffersize];
  281.       bufcolumn = new int[buffersize];
  282.     }
  283.     prevCharIsLF = prevCharIsCR = false;
  284.     tokenBegin = inBuf = maxNextCharInd = 0;
  285.     bufpos = -1;
  286.   }
  287.  
  288.   public void ReInit(java.io.Reader dReader, int startline,
  289.                                                            int startcolumn)
  290.   {
  291.      ReInit(dReader, startline, startcolumn, 4096);
  292.   }
  293.  
  294.   public final String GetImage()
  295.   {
  296.      if (bufpos >= tokenBegin)
  297.         return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
  298.      else
  299.         return new String(buffer, tokenBegin, bufsize - tokenBegin) +
  300.                               new String(buffer,  0, bufpos + 1);
  301.   }
  302.  
  303.   public final char[] GetSuffix(int len)
  304.   {
  305.      char[] ret = new char[len];
  306.  
  307.      if ((bufpos + 1) >= len)
  308.         System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
  309.      else
  310.      {
  311.         System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
  312.                                                           len - bufpos - 1);
  313.         System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
  314.      }
  315.  
  316.      return ret;
  317.   }
  318.  
  319.   public void Done()
  320.   {
  321.      buffer = null;
  322.      bufline = null;
  323.      bufcolumn = null;
  324.   }
  325.  
  326. }
  327.